package cn.iocoder.boot.utils;

import cn.hutool.core.util.StrUtil;

import cn.iocoder.boot.service.ExcelToJsonArray;
import lombok.extern.slf4j.Slf4j;
import org.apache.poi.ss.usermodel.*;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileWriter;
import java.io.IOException;

@Slf4j
public class ExcelToMarkdownConverter {

    public static String excelToMarkdown(MultipartFile multipartFile) throws IOException {
        // 创建临时文件
        File tempFile = File.createTempFile("temp", multipartFile.getOriginalFilename());
        tempFile.deleteOnExit(); // 确保临时文件在程序退出时被删除
        // 将 MultipartFile 保存到临时文件
        multipartFile.transferTo(tempFile);
        // 从临时文件创建 FileInputStream
//        FileInputStream fis = new FileInputStream(tempFile);
        Workbook workbook = ExcelToJsonArray.getWorkbookByFilePath(tempFile.getAbsolutePath());
        try {
            Sheet sheet = workbook.getSheetAt(0); // 获取第一个工作表
            StringBuilder markdownContent = new StringBuilder();
            markdownContent.append("## 原始").append("\n");
            // 遍历每一行
            for (Row row : sheet) {
                StringBuilder rowContent = new StringBuilder("| ");
                StringBuilder headerSeparator = new StringBuilder("| ");
                // 遍历每一列
                for (Cell cell : row) {
                    if (cell.getColumnIndex() >= row.getLastCellNum() - 1) {
                        break;
                    }
                    switch (cell.getCellType()) {
                        case STRING:
                            rowContent.append(cell.getStringCellValue());
                            headerSeparator.append("---|");
                            break;
                        case NUMERIC:
                            if (DateUtil.isCellDateFormatted(cell)) {
                                rowContent.append(cell.getDateCellValue());
                            } else {
                                rowContent.append(cell.getNumericCellValue());
                            }
                            headerSeparator.append("---:|");
                            break;
                        case BOOLEAN:
                            rowContent.append(cell.getBooleanCellValue());
                            headerSeparator.append("---:|");
                            break;
                        case FORMULA:
                            rowContent.append(cell.getCellFormula());
                            headerSeparator.append("---:|");
                            break;
                        default:
                            rowContent.append(" ");
                            headerSeparator.append("---|");
                            break;
                    }
//                    if (cell.getColumnIndex() < row.getLastCellNum() - 1) {
                    rowContent.append(" | ");
//                    }
                }

                String trimmedString = rowContent.toString().trim();
                StringBuilder rowContentTrim = new StringBuilder(trimmedString);
                markdownContent.append(rowContentTrim).append("\n");
                // 添加表头分隔行
                if (row.getRowNum() == 0) {
                    markdownContent.append(headerSeparator).append("\n");
                }
            }
            log.info("转换结果:{}", markdownContent.toString());
            return markdownContent.toString();
        } catch (Exception e) {
            log.error("excelToMarkdown异常", e);
        }
        return null;
    }

    public static String convertExcelToMD(MultipartFile multipartFile) throws IOException {
        // 创建临时文件
        File tempFile = File.createTempFile("temp", multipartFile.getOriginalFilename());
        tempFile.deleteOnExit(); // 确保临时文件在程序退出时被删除
        // 将 MultipartFile 保存到临时文件
        multipartFile.transferTo(tempFile);
        // 从临时文件创建 FileInputStream
//        FileInputStream fis = new FileInputStream(tempFile);
        Workbook workbook = ExcelToJsonArray.getWorkbookByFilePath(tempFile.getAbsolutePath());

        Sheet sheet = workbook.getSheetAt(0);
        StringBuilder mdBuilder = new StringBuilder();
        mdBuilder.append("## " + sheet.getSheetName()).append("\n");
        // 处理表头
        Row headerRow = sheet.getRow(0);
        if (headerRow == null) {
            // 循环找2至10行，不为null则跳出循环
            for (int i = 1; i <= 10; i++) {
                Row row = sheet.getRow(i);
                if (row != null) {
                    headerRow = row;
                    break;
                }
            }
//            return null;
        }
        mdBuilder.append("| ");
//        for (Cell cell : headerRow) {
//            mdBuilder.append(getCellValue(cell)).append(" | ");
//        }
        for (int j = 0; j < headerRow.getLastCellNum(); j++) {
            Cell cell = headerRow.getCell(j);
            mdBuilder.append(getCellValue(cell)).append(" | ");
        }
        mdBuilder.append("\n");

        // 添加分隔线
        mdBuilder.append("|");
        for (int i = 0; i < headerRow.getLastCellNum(); i++) {
            mdBuilder.append("---|");
        }
        mdBuilder.append("\n");

        // 处理数据行
        for (int i = 1; i <= sheet.getLastRowNum(); i++) {
            Row row = sheet.getRow(i);
            if (row == null) continue;
            // 跳过隐藏行
            if (row.getZeroHeight()) continue;
            // 校验最后一行为空行退出
            if (i == sheet.getLastRowNum()) {
                boolean isBlankRow = true;
                for (int j = 0; j < row.getLastCellNum(); j++) {
                    Cell cell = row.getCell(j);
                    if (!"NaN".equals(getCellValue(cell))) {
                        isBlankRow = false;
                        break;
                    }
                }
                if (isBlankRow) break;
            }
//            log.info("row.size:={}", row.getLastCellNum());
            mdBuilder.append("| ");
//            int ii = 0;
//            for (Cell cell : row) {
//                mdBuilder.append(getCellValue(cell)).append(" | ");
//                ii++;
//            }
            for (int j = 0; j < row.getLastCellNum(); j++) {
                // 如果该列是隐藏的，则跳过
                if (sheet.isColumnHidden(j)) {
                    continue;
                }
                Cell cell = row.getCell(j);
                mdBuilder.append(getCellValue(cell)).append(" | ");
            }
//            log.info("ii:={}", ii);
            mdBuilder.append("\n");
        }
        return mdBuilder.toString();
    }

    /**
     * 获取单元格值的通用方法
     */
    private static String getCellValue(Cell cell) {
        if (cell == null) return "NaN";

        DataFormatter formatter = new DataFormatter();
        String value = formatter.formatCellValue(cell)
                .replace("|", "\\|")  // 转义Markdown特殊字符
                .replace("\n", " ")
                .replace("\r\n", " "); // 处理换行符
        // 判断单元格是否包含公式
        if (cell.getCellType() == CellType.FORMULA) {
            // 获取公式计算结果的类型
            CellType formulaResultType = cell.getCachedFormulaResultType();

            if (formulaResultType == CellType.STRING) {
                // 如果公式结果是字符串类型
                value = cell.getStringCellValue();
//                System.out.println("公式结果(字符串): " + value3);
            } else if (formulaResultType == CellType.NUMERIC) {
                // 如果公式结果是数值类型
                double numericValue = cell.getNumericCellValue();
                value = String.valueOf(numericValue);
//                String formattedNumericValue = formatter.formatCellValue(cell); // 格式化数值
//                System.out.println("公式结果(数值): " + formattedNumericValue);
            } else if(formulaResultType == CellType.ERROR) {
                value = "";
            } else {
                // 其他类型（如布尔值等）
                value = formatter.formatCellValue(cell);
                log.info("公式结果(其他类型): " + formatter.formatCellValue(cell));
            }
//            System.out.println("公式内容: " + formula);
        } else {
            // 如果不是公式单元格，则使用 formatCellValue 获取值
//            String value2 = formatter.formatCellValue(cell);
//            System.out.println("单元格值: " + value2);
        }
        // 特殊处理数字格式（可选）
        if (cell.getCellType() == CellType.NUMERIC && !DateUtil.isCellDateFormatted(cell)) {
            double num = cell.getNumericCellValue();
            if (num == (int) num) {
                return String.valueOf((int) num);
            }
        }
        if (StrUtil.isBlank(value)) {
            return "NaN";
        }
        return value;
    }

    public static void main(String[] args) {
        String excelFilePath = "D:\\E\\work\\智能体\\元器件报价BOM文件\\元器件报价BOM文件\\BM24121316749\\BOM\\电源RY4500 - 副本.xlsx";
        String markdownFilePath = "D:\\E\\work\\智能体\\元器件报价BOM文件\\元器件报价BOM文件\\BM24121316749\\BOM\\电源RY4500 - 副本.md";

        try (FileInputStream fis = new FileInputStream(excelFilePath);
             Workbook workbook = new XSSFWorkbook(fis);
             FileWriter writer = new FileWriter(markdownFilePath)) {

            Sheet sheet = workbook.getSheetAt(0); // 获取第一个工作表
            StringBuilder markdownContent = new StringBuilder();

            // 遍历每一行
            for (Row row : sheet) {
                StringBuilder rowContent = new StringBuilder("| ");
                StringBuilder headerSeparator = new StringBuilder("| ");

                // 遍历每一列
                for (Cell cell : row) {
                    switch (cell.getCellType()) {
                        case STRING:
                            rowContent.append(cell.getStringCellValue());
                            headerSeparator.append("---|");
                            break;
                        case NUMERIC:
                            if (DateUtil.isCellDateFormatted(cell)) {
                                rowContent.append(cell.getDateCellValue());
                            } else {
                                rowContent.append(cell.getNumericCellValue());
                            }
                            headerSeparator.append("---:|");
                            break;
                        case BOOLEAN:
                            rowContent.append(cell.getBooleanCellValue());
                            headerSeparator.append("---:|");
                            break;
                        case FORMULA:
                            rowContent.append(cell.getCellFormula());
                            headerSeparator.append("---:|");
                            break;
                        default:
                            rowContent.append(" ");
                            headerSeparator.append("---|");
                            break;
                    }
//                    System.out.println("rowContent:"+rowContent);
                    if (cell.getColumnIndex() < row.getLastCellNum()) {
                        rowContent.append(" | ");
                    }
                }

                markdownContent.append(rowContent).append("\n");

                // 添加表头分隔行
                if (row.getRowNum() == 0) {
                    markdownContent.append(headerSeparator).append("\n");
                }
            }
//            writer.write(markdownContent.toString());
            System.out.println("markdownContent.toString():"+markdownContent.toString());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
